package net.tycmc.cty.ctyms.timejob.common;

import java.util.List;

/**
 * 4.7数据质量
 * 异常数据处理类
 * 统一判断数据是否在合理范围内
 * author：wangkai
 * time：2015-06-27
*/
public class ExceptionDataProcess {
	
	/**
	 * 日工作小时
	 * @param Hours:工作小时数,BeginTime:开始时间，EndTime:结束时间,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String hours 工作小时数,若【工作小时数】值在【0，24*天数】范围内，则返回【工作小时数】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String Hours(Object Hours,String BeginTime,String EndTime,int VclNum,int Scale){
		//参数异常处理
		if(Hours==null || Hours.toString().equals("") || Hours.toString().equals("--")){
			return "--";
		}
		if(BeginTime==null || BeginTime.equals("") || BeginTime.equals("--")){
			return "--";
		}
		if(EndTime==null || EndTime.equals("") || EndTime.equals("--")){
			return "--";
		}
		String hours =  Hours.toString();
		String bgnTime = BeginTime;
		String endTime = EndTime;
		int vclNum = VclNum;
		int days = 0;
		//处理开始时间和结束时间，让时间为：yyyy-MM-dd HH:mm:ss
		if(bgnTime.length()<11){
			bgnTime += " 00:00:00";
		}else if(bgnTime.length()<14){
			bgnTime += ":00:00";
		}else if(bgnTime.length()<17){
			bgnTime += ":00";
		}
		if(endTime.length()<11){
			endTime += " 23:59:59";
		}else if(endTime.length()<14){
			endTime += ":59:59";
		}else if(endTime.length()<17){
			endTime += ":59";
		}
		if(!DateRegUtil.compare(endTime,bgnTime,"yyyy-MM-dd HH:mm:ss")){
			System.out.println("方法:Hours 执行:结束日期大于开始日期异常，开始日期："+BeginTime+"，结束日期："+EndTime);
			return "--";
		}
		if(vclNum<=0){
			System.out.println("方法:Hours 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}else{
			//获取开始时间和结束时间的间隔天数
			days = DateRegUtil.getDaysOfTimeDef(new String[]{bgnTime,endTime});
			//若【工作小时数】值在【0，24*天数】范围内，则返回【工作小时数】（需进行四舍五入）；若不在范围内，则返回“--”
			if(Double.parseDouble(hours)>=0 && Double.parseDouble(hours)<=24*days*vclNum){
				hours = NumberFormat.round(Double.parseDouble(hours),Scale)+"";
			}else{
				hours = "--";
			}
		}
		return hours;
	}
	
	/**
	 * 累积工作小时
	 * @param Hours:工作小时数,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String totalHhours 累计工作小时数,若【累积工作小时数】值在【0,99999999*设备数量】范围内，则返回【工作小时数】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String TotalHours(Object Hours,int VclNum,int Scale){
		//参数异常处理
		if(Hours==null || Hours.toString().equals("") || Hours.toString().equals("--")){
			return "--";
		}
		String totalHhours = Hours.toString();
		if(VclNum<=0){
			System.out.println("方法:TotalHours 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}
		//若【累积工作小时数】值在【0,99999999*设备数量】范围内，则返回【工作小时数】（需进行四舍五入）；若不在范围内，则返回“--”
		if(Double.parseDouble(totalHhours)>=0 && Double.parseDouble(totalHhours)<=99999999*VclNum){
			totalHhours = NumberFormat.round(Double.parseDouble(totalHhours),Scale)+"";
		}else{
			totalHhours = "--";
		}
		return totalHhours;
	}
	
	/**
	 * 每天公里数
	 * @param runkm:里程,BeginTime:开始时间，EndTime:结束时间,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String runkm 里程,若【里程】值在【0,3000*天数】范围内，则返回【里程】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String RunKm(Object runkm,String BeginTime,String EndTime,int VclNum,int Scale){
		//参数异常处理
		if(runkm==null || runkm.toString().equals("--") || runkm.toString().equals("")){
			return "--";
		}
		if(BeginTime==null || BeginTime.equals("") || BeginTime.equals("--")){
			return "--";
		}
		if(EndTime==null || EndTime.equals("") || EndTime.equals("--")){
			return "--";
		}
		String vclRunKm = runkm.toString();
		String bgnTime = BeginTime;
		String endTime = EndTime;
		int vclNum = VclNum;
		int days = 0;
		//处理开始时间和结束时间，让时间为：yyyy-MM-dd HH:mm:ss
		if(bgnTime.length()<11){
			bgnTime += " 00:00:00";
		}else if(bgnTime.length()<14){
			bgnTime += ":00:00";
		}else if(bgnTime.length()<17){
			bgnTime += ":00";
		}
		if(endTime.length()<11){
			endTime += " 23:59:59";
		}else if(endTime.length()<14){
			endTime += ":59:59";
		}else if(endTime.length()<17){
			endTime += ":59";
		}
		if(!DateRegUtil.compare(endTime,bgnTime,"yyyy-MM-dd HH:mm:ss")){
			System.out.println("方法:RunKm 执行:结束日期大于开始日期异常，开始日期："+BeginTime+"，结束日期："+EndTime);
			return "--";
		}
		if(vclNum<=0){
			System.out.println("方法:RunKm 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}else{
			//获取开始时间和结束时间的间隔天数
			days = DateRegUtil.getDaysOfTimeDef(new String[]{bgnTime,endTime});
			//若【里程】值在【0,3000*天数】范围内，则返回【里程】（需进行四舍五入）；若不在范围内，则返回“--”
			if(Double.parseDouble(vclRunKm)>=0 && Double.parseDouble(vclRunKm)<=3000*days*vclNum){
				vclRunKm = NumberFormat.round(Double.parseDouble(vclRunKm),Scale)+"";
			}else{
				vclRunKm = "--";
			}
		}
		return vclRunKm;
	}
	
	/**
	 * 每天油耗量
	 * @param Oil:油耗量/L,BeginTime:开始时间，EndTime:结束时间,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String runOil 油耗量,若【油耗量/L】值在【0，1800*天数】范围内，则返回【油耗量】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String RunOil(Object Oil,String BeginTime,String EndTime,int VclNum,int Scale){
		//参数异常处理
		if(Oil==null || Oil.toString().equals("") || Oil.toString().equals("--")){
			return "--";
		}
		if(BeginTime==null || BeginTime.equals("") || BeginTime.equals("--")){
			return "--";
		}
		if(EndTime==null || EndTime.equals("") || EndTime.equals("--")){
			return "--";
		}
		String runOil = Oil.toString();
		String bgnTime = BeginTime;
		String endTime = EndTime;
		int vclNum = VclNum;
		int days = 0;
		//处理开始时间和结束时间，让时间为：yyyy-MM-dd HH:mm:ss

		if(bgnTime.length()<11){
			bgnTime += " 00:00:00";
		}else if(bgnTime.length()<14){
			bgnTime += ":00:00";
		}else if(bgnTime.length()<17){
			bgnTime += ":00";
		}
		if(endTime.length()<11){
			endTime += " 23:59:59";
		}else if(endTime.length()<14){
			endTime += ":59:59";
		}else if(endTime.length()<17){
			endTime += ":59";
		}

		if(!DateRegUtil.compare(endTime,bgnTime,"yyyy-MM-dd HH:mm:ss")){
			System.out.println("方法:RunOil 执行:结束日期大于开始日期异常，开始日期："+BeginTime+"，结束日期："+EndTime);
			return "--";
		}
		if(vclNum<=0){
			System.out.println("方法:RunOil 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}else{
			//获取开始时间和结束时间的间隔天数
			days = DateRegUtil.getDaysOfTimeDef(new String[]{bgnTime,endTime});
			//若【油耗量/L】值在【0，1800*天数】范围内，则返回【油耗量】（需进行四舍五入）；若不在范围内，则返回“--”
			if(Double.parseDouble(runOil)>=0 && Double.parseDouble(runOil)<=1800*days*vclNum){
				runOil = NumberFormat.round(Double.parseDouble(runOil),Scale)+"";
			}else{
				runOil = "--";
			}
		}
		return runOil;
	}
	
	/**
	 * 累积油耗量
	 * @param Oil:油耗量,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String totalRunOil 累计油耗量,若【累积油耗量/L】值在【0，99999999】范围内，则返回【累积油耗量】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String TotalRunOil(Object Oil,int VclNum,int Scale){
		//参数异常处理
		if(Oil==null || Oil.toString().equals("") || Oil.toString().equals("--")){
			return "--";
		}
		String totalRunOil = Oil.toString();
		if(VclNum<=0){
			System.out.println("方法:TotalRunOil 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}
		//若【累积油耗量/L】值在【0，99999999】范围内，则返回【累积油耗量】（需进行四舍五入）；若不在范围内，则返回“--”
		if(Double.parseDouble(totalRunOil)>=0 && Double.parseDouble(totalRunOil)<=99999999*VclNum){
			totalRunOil = NumberFormat.round(Double.parseDouble(totalRunOil),Scale)+"";
		}else{
			totalRunOil = "--";
		}
		return totalRunOil;
	}
	
	/**
	 * 每天尿素消耗量
	 * @param iUrea:尿素消耗量,BeginTime:开始时间，EndTime:结束时间,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String vclUrea 尿素消耗量,若【尿素消耗量】值在【0，200*天数】范围内，则返回【尿素消耗量】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String iUrea(Object iUrea,String BeginTime,String EndTime,int VclNum,int Scale){
		//参数异常处理
		if(iUrea==null || iUrea.toString().equals("") || iUrea.toString().equals("--")){
			return "--";
		}
		if(BeginTime==null || BeginTime.equals("") || BeginTime.equals("--")){
			return "--";
		}
		if(EndTime==null || EndTime.equals("") || EndTime.equals("--")){
			return "--";
		}
		String vclUrea = iUrea.toString();
		String bgnTime = BeginTime;
		String endTime = EndTime;
		int vclNum = VclNum;
		int days = 0;
		//处理开始时间和结束时间，让时间为：yyyy-MM-dd HH:mm:ss
		if(bgnTime.length()<11){
			bgnTime += " 00:00:00";
		}else if(bgnTime.length()<14){
			bgnTime += ":00:00";
		}else if(bgnTime.length()<17){
			bgnTime += ":00";
		}
		if(endTime.length()<11){
			endTime += " 23:59:59";
		}else if(endTime.length()<14){
			endTime += ":59:59";
		}else if(endTime.length()<17){
			endTime += ":59";
		}
		if(!DateRegUtil.compare(endTime,bgnTime,"yyyy-MM-dd HH:mm:ss")){
			System.out.println("方法:iUrea 执行:结束日期大于开始日期异常，开始日期："+BeginTime+"，结束日期："+EndTime);
			return "--";
		}
		if(vclNum<=0){
			System.out.println("方法:iUrea 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}else{
			//获取开始时间和结束时间的间隔天数
			days = DateRegUtil.getDaysOfTimeDef(new String[]{bgnTime,endTime});
			//若【尿素消耗量】值在【0，200*天数】范围内，则返回【尿素消耗量】（需进行四舍五入）；若不在范围内，则返回“--”
			if(Double.parseDouble(vclUrea)>=0 && Double.parseDouble(vclUrea)<=200*days*vclNum){
				vclUrea = NumberFormat.round(Double.parseDouble(vclUrea),Scale)+"";
			}else{
				vclUrea = "--";
			}
		}
		return vclUrea;
	}
	
	/**
	 * 每天怠速油耗
	 * @param idle:怠速油耗,BeginTime:开始时间，EndTime:结束时间,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String vclUrea 怠速油耗,若【怠速油耗】值在【0，200*天数】范围内，则返回【怠速油耗】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String idle(Object idle,String BeginTime,String EndTime,int VclNum,int Scale){
		//参数异常处理
		if(idle==null || idle.toString().equals("") || idle.toString().equals("--")){
			return "--";
		}
		if(BeginTime==null || BeginTime.equals("") || BeginTime.equals("--")){
			return "--";
		}
		if(EndTime==null || EndTime.equals("") || EndTime.equals("--")){
			return "--";
		}
		String iDle = idle.toString();
		String bgnTime = BeginTime;
		String endTime = EndTime;
		int vclNum = VclNum;
		int days = 0;
		//处理开始时间和结束时间，让时间为：yyyy-MM-dd HH:mm:ss
		if(bgnTime.length()<11){
			bgnTime += " 00:00:00";
		}else if(bgnTime.length()<14){
			bgnTime += ":00:00";
		}else if(bgnTime.length()<17){
			bgnTime += ":00";
		}
		if(endTime.length()<11){
			endTime += " 23:59:59";
		}else if(endTime.length()<14){
			endTime += ":59:59";
		}else if(endTime.length()<17){
			endTime += ":59";
		}
		if(!DateRegUtil.compare(endTime,bgnTime,"yyyy-MM-dd HH:mm:ss")){
			System.out.println("方法:idle 执行:结束日期大于开始日期异常，开始日期："+BeginTime+"，结束日期："+EndTime);
			return "--";
		}
		if(vclNum<=0){
			System.out.println("方法:idle 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}else{
			//获取开始时间和结束时间的间隔天数
			days = DateRegUtil.getDaysOfTimeDef(new String[]{bgnTime,endTime});
			//若【怠速油耗】值在【0，200*天数】范围内，则返回【怠速油耗】（需进行四舍五入）；若不在范围内，则返回“--”
			if(Double.parseDouble(iDle)>=0 && Double.parseDouble(iDle)<=200*days*vclNum){
				iDle = NumberFormat.round(Double.parseDouble(iDle),Scale)+"";
			}else{
				iDle = "--";
			}
		}
		return iDle;
	}
	
	/**
	 * 累积怠速油耗
	 * @param idle:累积怠速油耗量,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String totalIdle 累积怠速油耗量,若【累积怠速油耗】值在【0，99999999】范围内，则返回【累积怠速油耗】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String Totalidle(Object idle,int VclNum,int Scale){
		//参数异常处理
		if(idle==null || idle.toString().equals("") || idle.toString().equals("--")){
			return "--";
		}
		String totalIdle = idle.toString();
		if(VclNum<=0){
			System.out.println("方法:Totalidle 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}
		//若【累积怠速油耗】值在【0，99999999】范围内，则返回【累积怠速油耗】（需进行四舍五入）；若不在范围内，则返回“--”
		if(Double.parseDouble(totalIdle)>=0 && Double.parseDouble(totalIdle)<=99999999*VclNum){
			totalIdle = NumberFormat.round(Double.parseDouble(totalIdle),Scale)+"";
		}else{
			totalIdle = "--";
		}
		return totalIdle;
	}
	
	/**
	 * @param data:传入数据,Scale:精确小数点的位数
	 * 
	 * @return String result 结果,若【其他数据】值不为空，则返回【小数转换成百分数】（需进行四舍五入）；否则，则返回“--”
	 * @author wangkai
	 * 其他数据统一处理
	 * */
	public static String UnityDataProcess(Object data,int Scale){
		String result = "";
		//参数异常处理
		if(data==null || data.toString().equals("") || data.toString().equals("--")){
			return "--";
		}
		result = data.toString();
		result = NumberFormat.round(Double.parseDouble(result),Scale)+"";
		return result;
		
	}
	
	/**
	 * @param data:传入数据,Scale:精确小数点的位数
	 * 
	 * @return String result 结果,若【其他数据】值不为空，则返回【小数转换成百分数】（需进行四舍五入）；否则，则返回“--”
	 * @author wangkai
	 * 其他数据统一处理
	 * */
	public static String AvgSpd(Object data,int Scale){
		//参数异常处理
		if(data==null || data.toString().equals("") || data.toString().equals("--")){
			return "--";
		}
		String averageSpeed="";
		double avSpeed=Double.parseDouble(data.toString());
		if(avSpeed>=0 && avSpeed<=250.996){
			avSpeed=NumberFormat.round(avSpeed,2);
			averageSpeed = avSpeed+"";
			
			//进行补0，如保留两位小数结果为2.5需返回2.50
			averageSpeed = UnifideCaculation.add0(averageSpeed, Scale);
		}else{
			averageSpeed="--";
		}
		return averageSpeed;
		
	}
	
	/**
	 * @param data:传入数据,Scale:精确小数点的位数
	 * 
	 * @return String result 结果,若【其他数据】值不为空，则返回【小数转换成百分数】（需进行四舍五入）；否则，则返回“--”
	 * @author wangkai
	 * 其他数据统一处理
	 * */
	public static String OilPerKm(Object data,int Scale){
		//参数异常处理
		if(data==null || data.toString().equals("") || data.toString().equals("--")){
			return "--";
		}
		String OilPerKm="";
		double oilper=Double.parseDouble(data.toString());
		if(oilper>=0 && oilper<=100){
			OilPerKm = oilper+"";
			//进行补0，如保留两位小数结果为2.5需返回2.50
			OilPerKm = UnifideCaculation.add0(OilPerKm, Scale);
		}else{
			OilPerKm="--";
		}
		return OilPerKm;
		
	}
	
	/**
	 * 百分比
	 * @param resultPre:小数形式的值,Scale:精确小数点的位数
	 * 
	 * @return String percent 百分比,若【小数】值在【0，1】范围内，则返回【小数转换成百分数】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String ComParePrecent(Object resultPre,int Scale){
		//参数异常处理
		if(resultPre==null || resultPre.toString().equals("") || resultPre.toString().equals("--")){
			return "--";
		}
		String percent = resultPre.toString();
		//若【小数】值在【0，1】范围内，则返回【小数转换成百分数】（需进行四舍五入）；若不在范围内，则返回“--”
		if(Double.parseDouble(percent)>=0 && Double.parseDouble(percent)<=1){
			percent = NumberFormat.round(Double.parseDouble(percent)*100,Scale)+"%";
		}else{
			percent = "--";
		}
		return percent;
	}

	/**
	 * 累积里程
	 * @param RunKm:累计里程,VclNum:设备数量,Scale:精确小数点的位数
	 * 
	 * @return String totalRunKm 累计里程,若【累计里程】值在【0,99999999*设备数量】范围内，则返回【累计里程】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String TotalRunKm(Object RunKm,int VclNum,int Scale){
		//参数异常处理
		if(RunKm==null || RunKm.toString().equals("") || RunKm.toString().equals("--")){
			return "--";
		}
		String totalRunKm = RunKm.toString();
		if(VclNum<=0){
			System.out.println("方法:TotalRunKm 执行:获取设备数量异常，设备数量为："+VclNum);
			return "--";
		}
		//若【累积里程】值在【0,99999999*设备数量】范围内，则返回【工作小时数】（需进行四舍五入）；若不在范围内，则返回“--”
		if(Double.parseDouble(totalRunKm)>=0 && Double.parseDouble(totalRunKm)<=99999999*VclNum){
			totalRunKm = NumberFormat.round(Double.parseDouble(totalRunKm),Scale)+"";
		}else{
			totalRunKm = "--";
		}
		return totalRunKm;
	}
	/**
	 * 平均载重异常值处理
	 * @param AvLoad:平均载重,Scale:精确小数点的位数
	 * 
	 * @return String avLoad 平均载重,若【平均载重】值在【0,+∞】范围内，则返回【平均载重】（需进行四舍五入）；若不在范围内，则返回“--”
	 * @author wangkai
	 * */
	public static String avLoad(Object AvLoad,int Scale){
		//参数异常处理
		if(AvLoad==null || AvLoad.toString().equals("") || AvLoad.toString().equals("--")){
			return "--";
		}
		String avLoad = AvLoad.toString();
		//若【平均载重】值在【0,+∞】范围内，则返回【平均载重】（需进行四舍五入）；若不在范围内，则返回“--”
		if(Double.parseDouble(avLoad)<0){
			return "--";
		}else{
			avLoad = NumberFormat.round(Double.parseDouble(avLoad),Scale)+"";
		}
		return avLoad;
	}
	
	
	public static void main(String[] args) {
		RunOil(10,"2015-06-22","2015-06-22 23:59:59", 1, 2);
		int days = DateRegUtil.getDaysOfTimeDef(new String[]{"2015-06-22","2015-06-22"});
		List<String> list = DateRegUtil.iterateTime("2015-06-24 23:59:59","2015-06-23 00:16:01");
		boolean is = DateRegUtil.compare("2015-06-25 23:59:23","2015-06-23 00:16:12","yyyy-MM-dd HH:mm:ss");
		String hours  = ExceptionDataProcess.Hours("23.4688", "2015-06-22", "2015-06-24 23:59:59", 10, 3);
		String totalhours = ExceptionDataProcess.TotalHours(-1, 1, 5);
		String runkm = ExceptionDataProcess.RunKm(100.253, "2015-06-21 23:59:23", "2015-06-23 00:16:12", 10, 2);
		String runoil = ExceptionDataProcess.RunOil("15936.236", "2015-06-22", "2015-06-22 23:59:59", 10, 2);
		String totalrunoil = ExceptionDataProcess.TotalRunOil(1, 1, 5);
		String iUrea = ExceptionDataProcess.iUrea("1593.236", "2015-06-22", "2015-06-22 23:59:59", 10, 2);
		String idle = ExceptionDataProcess.idle("15932.36", "2015-06-22", "2015-06-22 23:59:59", 10, 2);
		String totalIdle = ExceptionDataProcess.Totalidle(-1, 1, 5);
		String sca =ExceptionDataProcess.UnityDataProcess("1.2365",2);
	    String percent = ExceptionDataProcess.ComParePrecent(0.1256, 2);
	    System.out.println(sca);
	    System.out.println("AVG:"+AvgSpd("1.5",2));
		System.out.println(days);
		System.out.println(list.size());
		System.out.println(hours);
		System.out.println(totalhours);
		System.out.println(runkm);
		System.out.println(runoil);
		System.out.println(totalrunoil);
		System.out.println(iUrea);
		System.out.println(idle);
		System.out.println(totalIdle);
		System.out.println(percent);
	}

}
